package cn.test.learnkotlin.v1
//基础语法

class ABaseGrammar {
    private class Greeter(val name: String) {
        fun greet() {
            println("Hello $name")
        }
    }

    private fun foo1() {
        Greeter("KentLee").greet()
    }

    /**
     * 函数定义
     */
    private fun sum(a: Int, b: Int): Int {
        return a + b
    }

    /**
     * 表达式作为函数体，返回类型自动推断
     */
    private fun sum1(a: Int, b: Int) = a + b

    private fun printSum(a: Int, b: Int): Unit {
        println(a + b)
    }

    /**
     * 返回是Unit类型，则可以省略返回类型
     */
    private fun printSum1(a: Int, b: Int) {
        println(a + b)
    }

    /**
     * 可变长参数函数
     * 可变长参数标识vararg
     */
    private fun vars(vararg v: Int) {
        for (i in v) {
            print(i)
        }
    }

    /**
     * lambda（匿名函数）
     */
    private fun fooLambda() {
        val sumLambda: (Int, Int) -> Int = { x, y -> x + y }
        print(sumLambda(1, 2))
    }

    /**
     * 可变变量定义
     * 非局变量需要初始化
     */
    private var a1: Int = 1

    /**
     * 不可变变量定义
     */
    private val b1: Int = 1

    private class InnerClass {
        /**
         * 非局部变量需要初始化
         */
        private var a1: Int = 1

        /**
         * 非局部变量需要初始化
         */
        private val b1: Int = 1

        private fun foo() {
            var a1: Int = 1

            /**
             * 自动推断变量类型为Int
             */
            var b1 = 1

            /**
             * 如不初始化则必须提供变量类型
             */
            val b2: Int

            var x = 5
            x += 1
        }
    }

    private fun fooStringPattern() {
        var a = 1
        val str = "a is $a"
        println(str)
        a += 1
        val str1 = "${str.replace("is", "was")}, but now is $a"
        print(str1)
    }

    private fun fooNullCheck() {
        var age: String? = "23"
        val ages = age!!.toInt()
        val ages1 = age?.toInt()
        val ages2 = age?.toInt() ?: -1
        print("age[$age], ages[$ages], ages1[$ages1], ages2[$ages2]")


    }

    private fun parseInt(str: String): Int? {
        return str.toIntOrNull()
    }

    private fun foo2() {
        val x = parseInt("1")
        val y = parseInt("ws")
        // 直接使用 `x * y` 会导致错误, 因为它们可能为 null.
        if (x != null && y != null) {
            // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
            print(x * y)
        }
    }

    /**
     * 我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。
     */
    private fun getStringLength1(obj: Any): Int? {
        if (obj is String) {
            return obj.length
        }
        return null
    }

    /**
     * 我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。
     */
    private fun getStringLength2(obj: Any): Int? {
        if (obj !is String) {
            return null
        }
        return obj.length
    }

    private fun fooRange() {
        //输出1234
        for (i in 1..4) print(i)
        print("\n")
        //什么都不输出，应该使用downTo
        for (i in 4..1) print(i)
        print("\n")
        //输出4321
        for (i in 4 downTo 1) print(i)
        print("\n")
        //使用step指定步长//输出13579
        for (i in 1..9 step 2) print(i)
        print("\n")
        //使用until函数排除结束元素//输出1357
        for (i in 1 until 9 step 2) print(i)
    }

    fun main() {
        println("-------------------------------------------------------------------------------------")
        //foo1()
        //fooLambda()
        //fooStringPattern()
        //fooNullCheck()
        fooRange()
        println("\n-------------------------------------------------------------------------------------")
    }
}

fun main() {
    ABaseGrammar().main()
}